I traced the code path. The issue is in python_spy.rs in _get_python_thread_name (around line 330):

fn _get_python_thread_name(&mut self, python_thread_id: u64) -> Option<String> {
    match self.python_thread_names.get(&python_thread_id) {
        Some(thread_name) => Some(thread_name.clone()),
        None => {
            self.python_thread_names = thread_name_lookup(self).unwrap_or_default();
            self.python_thread_names.get(&python_thread_id).cloned()
        }
    }
}

Two compounding problems:

1. O(N^2) per sample: _get_python_thread_name is called inside the thread loop in _get_stack_traces, once per PyThreadState. When N threads are uncached, the full thread_name_lookup (which traverses the entire threading._active dict) runs N times per sample instead of once.

2. No negative caching: When thread_name_lookup fails (threading module not imported, or threads created outside threading), unwrap_or_default() returns an empty HashMap. Every subsequent thread in the same sample — and every sample after — also misses, triggering the same failing lookup.

Fix: move the lookup out of the per-thread function and into _get_stack_traces, running it once per sample call, and add a bool flag to skip re-attempt after the first failure:

// Add to PythonSpy struct:
pub thread_name_lookup_attempted: bool,

// In _get_stack_traces, before the thread loop:
if !self.thread_name_lookup_attempted {
    self.python_thread_names = thread_name_lookup(self).unwrap_or_default();
    self.thread_name_lookup_attempted = true;
}

// Simplified _get_python_thread_name:
fn _get_python_thread_name(&mut self, python_thread_id: u64) -> Option<String> {
    self.python_thread_names.get(&python_thread_id).cloned()
}

This ensures the full dict walk happens exactly once per sample (or once ever if the threading module is absent). The stale-cache issue from recycled TIDs is already handled in _get_os_thread_id which clears python_thread_names when it detects a recycled TID, so correctness is preserved.